home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmigaPlus / Tools / Development / AmigaTalk / user / CPURegister.st < prev    next >
Text File  |  2004-01-31  |  8KB  |  285 lines
  1. " ---------------------------------------------------------------- "
  2. " Register.st - Implementation of an Abstract CPU register         "
  3. "               object.                                            "
  4. " ================================================================ "
  5. " numBits       = size (in bits) of the Register                   "  
  6. " contents      = the value in the Register                        "
  7. " window        = the GUI Window that the Register is displayed in "
  8. " numberBase    = Binary, Octal or Hexadecimal number base         "
  9. " intuiText     = IntuiText Object for the contents                "
  10. " labelIText    = Logical name of the Register (ex: 'PC')          "
  11. " containerBBox = Frame around the Register contents               " 
  12. " viObj         = visualInfo Object from the GUI Screen            "
  13. " ---------------------------------------------------------------- "
  14.  
  15. Class Register :Integer
  16. ! numBits       contents window         numberBase intuiText 
  17.   containerBBox viObj    defaultBoxType labelIText
  18. !
  19. [
  20.    new: regSize ! intuition !
  21.    
  22.      intuition <- Intuition new.
  23.      numBits   <- regSize.
  24.      contents  <- 0.
  25.      
  26.      defaultBoxType <- (intuition systemTag: #GTBB_Recessed).
  27.      
  28.      ^ self
  29. |
  30.    initializeLabel: labelText at: startPoint
  31.  
  32.      labelIText <- IText new: labelText.
  33.  
  34.      labelIText setITextOrigin: startPoint.
  35. |
  36.    initializeIText: theText at: startPoint
  37.    
  38.      intuiText <- IText new: theText.
  39.  
  40.      intuiText setITextOrigin: startPoint.
  41. |
  42.    attachTo: thisWindow ! scr !
  43.  
  44.      " window & screen already have to be open for this method: "
  45.  
  46.      window <- thisWindow.
  47.  
  48.      scr    <- window screen.
  49.  
  50.      viObj  <- scr getVisualInfo.
  51. |
  52.    containerType: newBoxType 
  53.    
  54.      " range: 0 to 3 "
  55.    
  56.      defaultBoxType <- newBoxType
  57. |
  58.    basis: newBasis
  59.    
  60.      numberBase <- newBasis
  61. |     
  62.    display: newValue at: startPoint
  63.    
  64.      self xxxErase: contents.
  65.      self value: newValue.
  66.      
  67.      intuiText setITextOrigin: startPoint.
  68.           
  69.      self xxxDrawContainer: defaultBoxType for: intuiText.
  70.      self xxxDrawContents:  contents.
  71.      self xxxDrawLabel:     labelIText.
  72. |
  73.    setupDisplayPens: fgBgPens
  74.  
  75.      " fgBgPens is a Point Object: "   
  76.  
  77.      intuiText setPens: fgBgPens
  78. |
  79.    value: newContents
  80.    
  81.      contents <- newContents
  82. |
  83.    value
  84.    
  85.      ^ contents
  86. |
  87.    xxxDrawContents: newContents
  88.    
  89.      intuiText setText: newContents
  90.      
  91.      window printIText: intuiText at: (intuiText getITextOrigin).
  92. |
  93.    xxxDrawLabel: labelContents
  94.    
  95.      labelIText setText: labelContents
  96.      
  97.      window printIText: labelIText at: (labelIText getITextOrigin).
  98. |
  99.    xxxErase: oldContents ! pens !
  100.    
  101.      pens <- intuiText getPens.
  102.      
  103.      intuiText setPens: (pens y) @ (pens x). " reverse the Pens "
  104.  
  105.      " Now draw over the displayed text: "     
  106.  
  107.      window printIText: intuiText at: (intuiText getITextOrigin).
  108. |
  109.    xxxContainerSize
  110.  
  111.      " textSize returns a Point Object: "
  112.         
  113.      ^ intuiText textSize. 
  114. |
  115.    xxxDrawContainer: boxType for: itext ! x y w h scr sizePt startPt !
  116.    
  117.      containerBBox <- BevelBox new.
  118.      
  119.      startPt       <- itext getITextOrigin.
  120.      sizePt        <- self xxxContainerSize.
  121.      
  122.      x <- startPt x.
  123.      y <- startPt y.
  124.      
  125.      (x > 2)
  126.         ifTrue:  [ x <- x - 2. w <- (sizePt x) + 2. ]
  127.         ifFalse: [ w <- (sizePt x) + 4 ].
  128.  
  129.      (y > 2)
  130.         ifTrue:  [ y <- y - 2. h <- (sizePt y) + 2. ]
  131.         ifFalse: [ h <- (sizePt y) + 4 ].
  132.         
  133.      containerBBox setupBoxX: x y: y width: w height: h flags: boxType.
  134.  
  135.      containerBBox drawBoxOn: window with: viObj.
  136. ]
  137.  
  138. " ---------------------------------------------------------------- "
  139. " ByteRegister.st - Implementation of an 8-bit CPU register        "
  140. "                   object.  Most of the methods are defined in    "
  141. " the parent class Register.                                       "
  142. " ================================================================ "
  143. " myBasis = Binary, Octal or Hexadecimal number base               "
  144. " ---------------------------------------------------------------- "
  145.  
  146. Class ByteRegister :Register ! myBasis !
  147. [
  148.    new: newValueString
  149.    
  150.      super new:   8.
  151.      super value: newValueString.
  152.      super basis: 2.
  153.      
  154.      myBasis <- 2.
  155.      
  156.      ^ self
  157. |
  158.    changeBasis: newBasis
  159.    
  160.      super basis: newBasis.
  161.      
  162.      myBasis <- newBasis.
  163. |
  164.    setContentsTo: newValue
  165.    
  166.      (newValue isKindOf: Integer)
  167.        ifTrue: [ (myBasis = 2) 
  168.                    ifTrue:  [ ^ super value: (newValue asBareBinary) ].
  169.                   
  170.                  (myBasis = 8)
  171.                    ifTrue:  [ ^ super value: (newValue asBareOctal) ].  
  172.                  
  173.                  (myBasis = 16)  
  174.                    ifTrue:  [ ^ super value: (newValue asBareHex) ]
  175.                    ifFalse: [ ^ super value: 'nil' ]            
  176.                ].
  177.  
  178.      (newValue isKindOf: String)
  179.        ifTrue:  [ ^ super value: newValue ]
  180.        ifFalse: [ ^ super value: 'nil' ]
  181. |
  182.    displayIn: thisWindow
  183.    
  184.      super attachTo: thisWindow.
  185. ]
  186.  
  187. " ---------------------------------------------------------------- "
  188. " WordRegister.st - Implementation of an 16-bit CPU register       "
  189. "                   object.  Most of the methods are defined in    "
  190. " the parent class Register.                                       "
  191. " ================================================================ "
  192. " myBasis = Binary, Octal or Hexadecimal number base               "
  193. " ---------------------------------------------------------------- "
  194.  
  195. Class WordRegister :Register ! myBasis !
  196. [
  197.    new: newValueString
  198.    
  199.      super new:   16.
  200.      super value: newValueString.
  201.      super basis: 2.
  202.      
  203.      myBasis <- 2.
  204.      
  205.      ^ self
  206. |
  207.    changeBasis: newBasis
  208.    
  209.      super basis: newBasis.
  210.      
  211.      myBasis <- newBasis.
  212. |
  213.    setContentsTo: newValue
  214.    
  215.      (newValue isKindOf: Integer)
  216.        ifTrue: [ (myBasis = 2) 
  217.                    ifTrue:  [ ^ super value: (newValue asBareBinary) ].
  218.                   
  219.                  (myBasis = 8)
  220.                    ifTrue:  [ ^ super value: (newValue asBareOctal) ].  
  221.                  
  222.                  (myBasis = 16)  
  223.                    ifTrue:  [ ^ super value: (newValue asBareHex) ]
  224.                    ifFalse: [ ^ super value: 'nil' ]            
  225.                ].
  226.  
  227.      (newValue isKindOf: String)
  228.        ifTrue:  [ ^ super value: newValue ]
  229.        ifFalse: [ ^ super value: 'nil' ]
  230. |
  231.    displayIn: thisWindow
  232.    
  233.      super attachTo: thisWindow.
  234. ]
  235.  
  236. " ---------------------------------------------------------------- "
  237. " LongWordRegister.st - Implementation of an 32-bit CPU register   "
  238. "                   object.  Most of the methods are defined in    "
  239. " the parent class Register.                                       "
  240. " ================================================================ "
  241. " myBasis = Binary, Octal or Hexadecimal number base               "
  242. " ---------------------------------------------------------------- "
  243.  
  244. Class LongWordRegister :Register ! myBasis !
  245. [
  246.    new: newValueString
  247.    
  248.      super new:   32.
  249.      super value: newValueString.
  250.      super basis: 16.
  251.      
  252.      myBasis <- 16.
  253.      
  254.      ^ self
  255. |
  256.    changeBasis: newBasis
  257.    
  258.      super basis: newBasis.
  259.      
  260.      myBasis <- newBasis.
  261. |
  262.    setContentsTo: newValue
  263.    
  264.      (newValue isKindOf: Integer)
  265.        ifTrue: [ (myBasis = 2) 
  266.                    ifTrue:  [ ^ super value: (newValue asBareBinary) ].
  267.                   
  268.                  (myBasis = 8)
  269.                    ifTrue:  [ ^ super value: (newValue asBareOctal) ].  
  270.                  
  271.                  (myBasis = 16)  
  272.                    ifTrue:  [ ^ super value: (newValue asBareHex) ]
  273.                    ifFalse: [ ^ super value: 'nil' ]            
  274.                ].
  275.  
  276.      (newValue isKindOf: String)
  277.        ifTrue:  [ ^ super value: newValue ]
  278.        ifFalse: [ ^ super value: 'nil' ]
  279. |
  280.    displayIn: thisWindow
  281.    
  282.      super attachTo: thisWindow.
  283. ]
  284.  
  285.